home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gp_vms.c < prev    next >
C/C++ Source or Header  |  1996-09-02  |  13KB  |  423 lines
  1. /* Copyright (C) 1989, 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gp_vms.c */
  20. /* VAX/VMS specific routines for Ghostscript */
  21. #include "string_.h"
  22. #include "gx.h"
  23. #include "gp.h"
  24. #include <stat.h>
  25. #include <stdlib.h>        /* for exit() */
  26. #include <unixio.h>
  27.  
  28. extern char *getenv(P1(const char *));
  29.  
  30. /* Apparently gcc doesn't allow extra arguments for fopen: */
  31. #ifdef VMS        /* DEC C */
  32. #  define fopen_VMS fopen
  33. #else            /* gcc */
  34. #  define fopen_VMS(name, mode, m1, m2) fopen(name, mode)
  35. #endif
  36.  
  37.  
  38. /* VMS string descriptor structure */
  39. #define DSC$K_DTYPE_T 14
  40. #define DSC$K_CLASS_S  1
  41. struct dsc$descriptor_s {
  42.     unsigned short    dsc$w_length;
  43.     unsigned char    dsc$b_dtype;
  44.     unsigned char    dsc$b_class;
  45.     char        *dsc$a_pointer;
  46. };
  47. typedef struct dsc$descriptor_s descrip;
  48.  
  49. /* VMS RMS constants */
  50. #define RMS$_NMF    99018
  51. #define RMS$_NORMAL 65537
  52. #define NAM$C_MAXRSS  255
  53.  
  54. struct file_enum_s {
  55.   uint context, length;
  56.   descrip *pattern;
  57. };
  58.  
  59. extern uint
  60.   LIB$FIND_FILE(descrip *, descrip *, uint *, descrip *, descrip *,
  61.         uint *, uint *),
  62.   LIB$FIND_FILE_END(uint *),
  63.   SYS$FILESCAN (descrip *, uint *, uint *),
  64.   SYS$PUTMSG (uint *, int (*)(), descrip *, uint);
  65.  
  66. private uint
  67. strlength(char *str, uint maxlen, char term)
  68. {    uint i = 0;
  69.     while ( i < maxlen && str[i] != term ) i++;
  70.     return i;
  71. }
  72.  
  73. /* Do platform-dependent initialization. */
  74. void
  75. gp_init(void)
  76. {
  77. }
  78.  
  79. /* Do platform-dependent cleanup. */
  80. void
  81. gp_exit(int exit_status, int code)
  82. {
  83. }
  84.  
  85. /* Exit the program. */
  86. void
  87. gp_do_exit(int exit_status)
  88. {    /* The program returns exit_status = 0 for OK, 1 for failure; */
  89.     /* VMS has different conventions. */
  90.     switch ( exit_status )
  91.       {
  92.       case 0:
  93.         exit(exit_OK);
  94.       case 1:
  95.         exit(exit_FAILED);
  96.       }
  97.     exit(exit_status);
  98. }
  99.  
  100. /* ------ Date and time ------ */
  101.  
  102. /* Read the current time (in seconds since Jan. 1, 1980) */
  103. /* and fraction (in nanoseconds). */
  104. void
  105. gp_get_realtime(long *pdt)
  106. {    struct {uint _l0, _l1;} binary_date, now, difference;
  107.     long lib$ediv(), lib$subx(), sys$bintim(), sys$gettim();
  108.     long units_per_second = 10000000;
  109.     char *jan_1_1980 = "1-JAN-1980 00:00:00.00";
  110.     descrip str_desc;
  111.  
  112.     /* For those interested, Wednesday, November 17, 1858 is the base
  113.        of the Modified Julian Day system adopted by the Smithsonian
  114.        Astrophysical Observatory in 1957 for satellite tracking.  (The
  115.        year 1858 preceded the oldest star catalog in use at the
  116.        observatory.)  VMS uses quadword time stamps which are offsets
  117.        in 100 nanosecond units from November 17, 1858.  With a 63-bit
  118.        absolute time representation (sign bit must be clear), VMS will
  119.        have no trouble with time until 31-JUL-31086 02:48:05.47. */
  120.  
  121.     /* Convert January 1, 1980 into a binary absolute time */
  122.     str_desc.dsc$w_length  = strlen(jan_1_1980);
  123.     str_desc.dsc$a_pointer = jan_1_1980;
  124.     (void) sys$bintim (&str_desc, &binary_date);
  125.  
  126.     /* Compute number of 100 nanosecond units since January 1, 1980.  */
  127.     (void) sys$gettim (&now);
  128.     (void) lib$subx (&now, &binary_date, &difference);
  129.  
  130.     /* Convert to seconds and nanoseconds.  */
  131.     (void) lib$ediv (&units_per_second, &difference, &pdt[0], &pdt[1]);
  132.     pdt[1] *= 100;
  133. }
  134.  
  135. /* Read the current user CPU time (in seconds) */
  136. /* and fraction (in nanoseconds).  */
  137. void
  138. gp_get_usertime(long *pdt)
  139. {    gp_get_realtime(pdt);    /* Use an approximation for now.  */
  140. }
  141.  
  142. /* ------ Screen management ------ */
  143.  
  144. /* Get the environment variable that specifies the display to use. */
  145. const char *
  146. gp_getenv_display(void)
  147. {    return getenv("DECW$DISPLAY");
  148. }
  149.  
  150. /* ------ Printer accessing ------ */
  151.  
  152. /* Open a connection to a printer.  A null file name means use the */
  153. /* standard printer connected to the machine, if any. */
  154. /* Return NULL if the connection could not be opened. */
  155. FILE *
  156. gp_open_printer(char *fname, int binary_mode)
  157. {
  158.      if (strlen(fname) == 0)
  159.     {    strcpy(fname, gp_scratch_file_name_prefix);
  160.         strcat(fname, "XXXXXX");
  161.         mktemp(fname);
  162.     }
  163.     if ( binary_mode )
  164.     {    /*
  165.          * Printing must be done exactly byte to byte,
  166.          * using "passall".  However the standard VMS symbiont
  167.          * does not treat stream-LF files correctly in this respect,
  168.          * but throws away \n characters.  Giving the file
  169.          * the record type "undefined", but accessing it as a
  170.          * normal stream-LF file does the trick.
  171.          */
  172.         return fopen_VMS(fname, "w", "rfm = udf", "ctx = stm");
  173.     }
  174.     else
  175.     {    /* Open as a normal text stream file. */
  176.         return fopen_VMS(fname, "w", "rfm = var", "rat = cr");
  177.     }
  178. }
  179.  
  180. /* Close the connection to the printer. */
  181. void
  182. gp_close_printer(FILE *pfile, const char *fname)
  183. {    fclose(pfile);
  184. }
  185.  
  186. /* ------ File naming and accessing ------ */
  187.  
  188. /* Define the character used for separating file names in a list. */
  189. const char gp_file_name_list_separator = ',';
  190.  
  191. /* Define the default scratch file name prefix. */
  192. const char gp_scratch_file_name_prefix[] = "_temp_";
  193.  
  194. /* Define the name of the null output file. */
  195. const char gp_null_file_name[] = "NLA0:";
  196.  
  197. /* Define the name that designates the current directory. */
  198. const char gp_current_directory_name[] = "[]";
  199.  
  200. /* Define the string to be concatenated with the file mode */
  201. /* for opening files without end-of-line conversion. */
  202. const char gp_fmode_binary_suffix[] = "";
  203. /* Define the file modes for binary reading or writing. */
  204. const char gp_fmode_rb[] = "r";
  205. const char gp_fmode_wb[] = "w";
  206.  
  207. /* Create and open a scratch file with a given name prefix. */
  208. /* Write the actual file name at fname. */
  209. FILE *
  210. gp_open_scratch_file(const char *prefix, char *fname, const char *mode)
  211. {    strcpy(fname, prefix);
  212.     strcat(fname, "XXXXXX");
  213.     mktemp(fname);
  214.     return fopen(fname, mode);
  215. }
  216.  
  217. /* Open a file with the given name, as a stream of uninterpreted bytes. */
  218. /* We have to do something special if the file was FTP'ed in binary mode. */
  219. /* Unfortunately, only DEC C supports the extra arguments to fopen. */
  220. FILE *
  221. gp_fopen(const char *fname, const char *mode)
  222. {
  223. #ifdef __DECC
  224. #define FAB$C_FIX 1
  225.         stat_t buffer;
  226.  
  227.         if ( stat((char *)fname, &buffer) == 0 )
  228.       if ( buffer.st_fab_rfm == FAB$C_FIX )
  229.         return fopen(fname, mode, "rfm=stmlf", "ctx=stm");
  230. #endif
  231.         return fopen(fname, mode);
  232. }
  233.  
  234. /*  Answer whether a file name contains a directory/device specification, i.e.,
  235.  *  is absolute (not directory- or device-relative).  Since for VMS, the concept
  236.  *  of an "absolute" file reference has no meaning.  As Ghostscript is here
  237.  *  merely checking to see if it will make sense to paste a path to the front
  238.  *  of the file name, we use the VMS system service SYS$FILESCAN to check that
  239.  *  the file name has no node, device, root, or directory specification: if all
  240.  *  four of these items are missing from the file name then it is considered to
  241.  *  a relative file name to which a path may be prefixed. (Roots are associated
  242.  *  with rooted logical names.)
  243.  */
  244.  
  245. bool
  246. gp_file_name_is_absolute(const char *fname, uint len)
  247. {
  248.     descrip str_desc;
  249.     /* SYS$FILESCAN takes a uint *, but we want to extract bits. */
  250.     union {
  251.         uint i;
  252.         struct {
  253.          unsigned fscn$v_node : 1;
  254.          unsigned fscn$v_device : 1;
  255.          unsigned fscn$v_root : 1;
  256.          unsigned fscn$v_directory : 1;
  257.          unsigned fscn$v_name : 1;
  258.          unsigned fscn$v_type : 1;
  259.          unsigned fscn$v_version : 1;
  260.          unsigned fscn$v_fill_23 : 1;
  261.         } s;
  262.     } flags;
  263.     uint zero = 0;
  264.  
  265.     str_desc.dsc$w_length  = len;
  266.     str_desc.dsc$a_pointer = (char *)fname;
  267.     SYS$FILESCAN (&str_desc, &zero, &flags.i);
  268.     if ( flags.s.fscn$v_directory || flags.s.fscn$v_root ||
  269.          flags.s.fscn$v_device    || flags.s.fscn$v_node) return true;
  270.     else return false;
  271. }
  272.  
  273. /* Answer the string to be used for combining a directory/device prefix */
  274. /* with a base file name.  The file name is known to not be absolute. */
  275. const char *
  276. gp_file_name_concat_string(const char *prefix, uint plen,
  277.                const char *fname, uint len)
  278. {
  279.     /*  Full VAX/VMS paths are of the form:
  280.      *
  281.      *    device:[root.][directory.subdirectory]filename.extension;version
  282.      *    logical:filename.extension;version
  283.      *
  284.      *  Roots are fairly rare and associated typically with rooted logical
  285.      *  names.
  286.      *
  287.      *  Examples:
  288.      *
  289.      *    DUA1:[GHOSTSCRIPT]GHOST.PS;1
  290.      *    THOR_DEC:[DOOF.A.B.C.D]FILE.DAT;-3
  291.      *    LOG:GHOST.PS  (LOG is a logical defined as DUA1:[GHOSTSCRIPT])
  292.      *    LOG:DOOF.DAT  (LOG is defined as DUA1, current directory is
  293.      *                   is used as the directory spec.)
  294.      *
  295.      */
  296.     if ( plen > 0 )
  297.       switch ( prefix[plen - 1] )
  298.        {    case ':': case ']': return "";
  299.        };
  300.     return ":";
  301. }
  302.  
  303. /* ------ Wild card file search procedures ------ */
  304.  
  305. private void
  306. gp_free_enumeration(file_enum *pfen)
  307. {
  308.     if (pfen) {
  309.       LIB$FIND_FILE_END(&pfen->context);
  310.       gs_free(pfen->pattern->dsc$a_pointer, pfen->length, 1,
  311.           "GP_ENUM(pattern)");
  312.       gs_free((char *)pfen->pattern, sizeof(descrip), 1,
  313.           "GP_ENUM(descriptor)");
  314.       gs_free((char *)pfen, sizeof(file_enum), 1,
  315.           "GP_ENUM(file_enum)");
  316.     }
  317. }
  318.  
  319. /* Begin an enumeration.  See gp.h for details. */
  320.  
  321. file_enum *
  322. gp_enumerate_files_init(const char *pat, uint patlen,
  323.   gs_memory_t *memory)
  324. {
  325.     file_enum *pfen;
  326.     uint i, len;
  327.     char *c, *newpat;
  328.  
  329.     pfen = (file_enum *)gs_malloc(sizeof (file_enum), 1,
  330.                       "GP_ENUM(file_enum)");
  331.     pfen->pattern = (descrip *)gs_malloc(sizeof (descrip), 1,
  332.                          "GP_ENUM(descriptor)");
  333.     newpat = (char *)gs_malloc(patlen, 1, "GP_ENUM(pattern)");
  334.  
  335.     /*  Copy the pattern removing backslash quoting characters and
  336.      *  transforming unquoted question marks, '?', to percent signs, '%'.
  337.      *  (VAX/VMS uses the wildcard '%' to represent exactly one character
  338.      *  and '*' to represent zero or more characters.  Any combination and
  339.      *  number of interspersed wildcards is permitted.)
  340.      */
  341.     c = newpat;
  342.     for ( i = 0; i < patlen; pat++, i++ )
  343.       switch (*pat) {
  344.         case '?'  :
  345.         *c++ = '%'; break;
  346.         case '\\' :
  347.         i++;
  348.         if (i < patlen) *c++ = *++pat;
  349.         break;
  350.         default   :
  351.         *c++ = *pat; break;
  352.       }
  353.     len = c - newpat;
  354.  
  355.     /* Pattern may not exceed 255 characters */
  356.     if (len > 255) {
  357.       gs_free(newpat, patlen, 1, "GP_ENUM(pattern)");
  358.       gs_free((char *)pfen->pattern, sizeof (descrip), 1,
  359.           "GP_ENUM(descriptor)");
  360.       gs_free((char *)pfen, sizeof (file_enum), 1, "GP_ENUM(file_enum)");
  361.       return (file_enum *)0;
  362.     }
  363.  
  364.     pfen->context = 0;
  365.     pfen->length = patlen;
  366.     pfen->pattern->dsc$w_length  = len;
  367.     pfen->pattern->dsc$b_dtype   = DSC$K_DTYPE_T;
  368.     pfen->pattern->dsc$b_class   = DSC$K_CLASS_S;
  369.     pfen->pattern->dsc$a_pointer = newpat;
  370.  
  371.     return pfen;
  372. }
  373.  
  374. /* Return the next file name in the enumeration.  The client passes in */
  375. /* a scratch string and a max length.  If the name of the next file fits, */
  376. /* the procedure returns the length.  If it doesn't fit, the procedure */
  377. /* returns max length +1.  If there are no more files, the procedure */
  378. /* returns -1. */
  379.  
  380. uint
  381. gp_enumerate_files_next(file_enum *pfen, char *ptr, uint maxlen)
  382. {
  383.     char *c, filnam[NAM$C_MAXRSS];
  384.     descrip result = {NAM$C_MAXRSS, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
  385.     uint i, len;
  386.   
  387.     result.dsc$a_pointer = filnam;
  388.  
  389.     /* Find the next file which matches the pattern */
  390.     i = LIB$FIND_FILE(pfen->pattern, &result, &pfen->context,
  391.               (descrip *)0, (descrip *)0, (uint *)0, (uint *)0);
  392.  
  393.     /* Check the return status */
  394.     if (i == RMS$_NMF) {
  395.       gp_free_enumeration (pfen);
  396.       return (uint)-1;
  397.     }
  398.     else if (i != RMS$_NORMAL) return 0;
  399.     else if ((len = strlength (filnam, NAM$C_MAXRSS, ' ')) > maxlen)
  400.       return maxlen+1;
  401.  
  402.     /* Copy the returned filename over to the input string ptr */
  403.     c = ptr;
  404.     for (i = 0; i < len; i++) *c++ = filnam[i];
  405.  
  406.     return len;
  407. }
  408.  
  409. /* Clean up a file enumeration.  This is only called to abandon */
  410. /* an enumeration partway through: ...next should do it if there are */
  411. /* no more files to enumerate.  This should deallocate the file_enum */
  412. /* structure and any subsidiary structures, strings, buffers, etc. */
  413.  
  414. void
  415. gp_enumerate_files_close(file_enum *pfen)
  416. {    gp_free_enumeration (pfen);
  417. }
  418.  
  419. const char *
  420. gp_strerror(int errnum)
  421. {    return NULL;
  422. }
  423.